home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Reference Guide / C-C++ Interactive Reference Guide.iso / c_ref / csource3 / 132_01 / cd.c < prev    next >
Text File  |  1985-08-21  |  10KB  |  579 lines
  1. /*    Small c compiler CD section    */
  2. /*    >>>>>>>> start of cc5 <<<<<<<<< */
  3. /* This section contains the expression parser */
  4. #INCLUDE CDEF.H
  5. /*
  6.     Modified    Feb, 1982  to add complement ~ unary operator
  7.     in heir10
  8.     Feb 6,1982    Changed pop()-add() sequences in heir8 and
  9.         heir11 to addstk().
  10. */
  11. expression()
  12. {
  13.     int lval[2];
  14.     if(heir1(lval))rvalue(lval);
  15. }
  16. heir1(lval)
  17.     int lval[];
  18. {    
  19.     int k,lval2[2];
  20.     k=heir2(lval);
  21.     if (match("="))
  22.         {if(k==0){needlval();return 0;
  23.             }
  24.         if(lval[1])push();
  25.         if(heir1(lval2))rvalue(lval2);
  26.         store(lval);
  27.         return 0;
  28.         }
  29.     else return k;
  30. }
  31. heir2(lval)
  32.     int lval[];
  33. {
  34.     int k,lval2[2];
  35.     k=heir3(lval);
  36.     blanks();
  37.     if(ch()!='|')return k;
  38.     if(k)rvalue(lval);
  39.     while(1)
  40.         {if(match("|"))
  41.             {push();
  42.             if(heir3(lval2)) rvalue(lval2);
  43.             pop();
  44.             or();
  45.             }
  46.         else return 0;
  47.         }
  48. }
  49. heir3(lval)
  50.     int lval[];
  51. {
  52.     int k,lval2[2];
  53.     k=heir4(lval);
  54.     blanks();
  55.     if(ch()!='^')return k;
  56.     if(k)rvalue(lval);
  57.     while(1)
  58.         {if(match("^"))
  59.             {push();
  60.             if(heir4(lval2))rvalue(lval2);
  61.             pop();
  62.             xor();
  63.             }
  64.         else return 0;
  65.         }
  66.     }
  67. heir4(lval)
  68.     int lval[];
  69.     {int k,lval2[2];
  70.     k=heir5(lval);
  71.     blanks();
  72.     if(ch()!='&')return k;
  73.     if(k)rvalue(lval);
  74.     while(1)
  75.         {if(match("&"))
  76.             {push();
  77.             if(heir5(lval2))rvalue(lval2);
  78.             pop();
  79.             and();
  80.             }
  81.         else return 0;
  82.         }
  83.     }
  84. heir5(lval)
  85.     int lval[];
  86.     {int k,lval2[2];
  87.     k=heir6(lval);
  88.     blanks();
  89.     if((streq(line+lptr,"==")==0)&&(streq(line+lptr,"!=")==0))return k;
  90.     if(k)rvalue(lval);
  91.     while(1)
  92.         {if(match("=="))
  93.             {push();
  94.             if(heir6(lval2))rvalue(lval2);
  95.             pop();
  96.             eq();
  97.             }
  98.         else if(match("!="))
  99.             {push();
  100.             if(heir6(lval2))rvalue(lval2);
  101.             pop();
  102.             ne();
  103.             }
  104.         else return 0;
  105.         }
  106.     }
  107. heir6(lval)
  108.     int lval[];
  109. {
  110.     int k,lval2[2];
  111.     k=heir7(lval);
  112.     blanks();
  113.     if((streq(line+lptr,"<")==0)&&(streq(line+lptr,">")==0)&&
  114.         (streq(line+lptr,"<=")==0)&&(streq(line+lptr,">=")==0))return k;
  115.     if(streq(line+lptr,">>"))return k;
  116.     if(streq(line+lptr,"<<"))return k;
  117. if(k)rvalue(lval);
  118. while(1)
  119.     {if(match("<="))
  120.         {push();
  121.         if(heir7(lval2))rvalue(lval2);
  122.         pop();
  123.         if(cptr=lval[0])
  124.             if(cptr[ident]==pointer)
  125.                 {ule();
  126.                 continue;
  127.                 }
  128.         if(cptr=lval2[0])
  129.             if(cptr[ident]==pointer)
  130.                 {ule();
  131.                 continue;
  132.                 }
  133.         le();
  134.         }
  135.     else if(match(">="))
  136.         {push();
  137.         if(heir7(lval2))rvalue(lval2);
  138.         pop();
  139.         if(cptr=lval[0])
  140.             if(cptr[ident]==pointer)
  141.                 {uge();
  142.                 continue;
  143.                 }
  144.         if(cptr=lval2[0])
  145.             if(cptr[ident]==pointer)
  146.                 {uge();
  147.                 continue;
  148.                 }
  149.         ge();
  150.         }
  151.     else if((streq(line+lptr,"<"))&&(streq(line+lptr,"<<")==0))
  152.         {inbyte();
  153.         push();
  154.         if(heir7(lval2))rvalue(lval2);
  155.         pop();
  156.         if(cptr=lval[0])
  157.             if(cptr[ident]==pointer)
  158.                 {ult();
  159.                 continue;
  160.                 }
  161.         if(cptr=lval2[0])
  162.             if(cptr[ident]==pointer)
  163.                 {ult();
  164.                 continue;
  165.                 }
  166.         lt();
  167.         }
  168.     else if((streq(line+lptr,">"))&&(streq(line+lptr,">>")==0))
  169.         {inbyte();
  170.         push();
  171.         if(heir7(lval2))rvalue(lval2);
  172.         pop();
  173.         if(cptr=lval[0])
  174.             if(cptr[ident]==pointer)
  175.                 {ugt();
  176.                 continue;
  177.                 }
  178.         if(cptr=lval2[0])
  179.             if(cptr[ident]==pointer)
  180.                 {ugt();
  181.                 continue;
  182.                 }
  183.         gt();
  184.         }
  185.     else return 0;
  186.     }
  187. }
  188. /* >>>>>>>> start of cc6 <<<<<<<<< */
  189. heir7(lval)
  190.     int lval[];
  191. {
  192.     int k,lval2[2];
  193.     k=heir8(lval);
  194.     blanks();
  195.     if((streq(line+lptr,">>")==0)&&(streq(line+lptr,"<<")==0))return k;
  196.     if(k)rvalue(lval);
  197.     while(1)
  198.         {if(match(">>"))
  199.             {push();
  200.             if(heir8(lval2))rvalue(lval2);
  201.             pop();
  202.             asr();
  203.             }
  204.         else if(match("<<"))
  205.             {push();
  206.             if(heir8(lval2))rvalue(lval2);
  207.             pop();
  208.             asl();
  209.             }
  210.         else return 0;
  211.         }
  212. }
  213. heir8(lval)
  214.     int lval[];
  215. {
  216.     int k,lval2[2];
  217.     k=heir9(lval);
  218.     blanks();
  219.     if((ch()!='+')&&(ch()!='-'))return k;
  220.     if(k)rvalue(lval);
  221.     while(1)
  222.         {if(match("+"))
  223.             {push();
  224.             if(heir9(lval2))rvalue(lval2);
  225.             if(cptr=lval[0])
  226.                 if((cptr[ident]==pointer)&&
  227.                     (cptr[type]==cint))
  228.                     doublereg();
  229.             addstk();
  230.             }
  231.         else if(match("-"))
  232.             {push();
  233.             if(heir9(lval2))rvalue(lval2);
  234.             if(cptr=lval[0])
  235.                 if((cptr[ident]==pointer)&&
  236.                     (cptr[type]==cint))
  237.                     doublereg();
  238.             pop();
  239.             sub();
  240.             }
  241.         else return 0;
  242.         }
  243. }
  244. heir9(lval)
  245.     int lval[];
  246. {
  247.     int k,lval2[2];
  248.     k=heir10(lval);
  249.     blanks();
  250.     if((ch()!='*')&&(ch()!='/')&&(ch()!='%'))return k;
  251.     if(k)rvalue(lval);
  252.     while(1)
  253.         {if(match("*"))
  254.             {push();
  255.             if(heir9(lval2))rvalue(lval2);
  256.             pop();
  257.             mult();
  258.             }
  259.         else if(match("/"))
  260.             {push();
  261.             if(heir10(lval2))rvalue(lval2);
  262.             pop();
  263.             div();
  264.             }
  265.         else if(match("%"))
  266.             {push();
  267.             if(heir10(lval2))rvalue(lval2);
  268.             pop();
  269.             mod();
  270.             }
  271.         else return 0;
  272.         }
  273. }
  274. heir10(lval)
  275.     int lval[];
  276. {
  277.     int k;
  278.     char *ptr;
  279.     if(match("++"))
  280.         {if((k=heir10(lval))==0)
  281.             {needlval();
  282.             return 0;
  283.             }
  284.         if(lval[1])push();
  285.         rvalue(lval);
  286.         inc();
  287.         ptr=lval[0];
  288.         if((ptr[ident]==pointer)&&(ptr[type]==cint))
  289.             inc();
  290.         store(lval);
  291.         return 0;
  292.         }
  293.     else if(match("--"))
  294.         {if((k=heir10(lval))==0)
  295.             {needlval();
  296.             return 0;
  297.             }
  298.         if(lval[1])push();
  299.         rvalue(lval);
  300.         dec();
  301.         ptr=lval[0];
  302.         if((ptr[ident]==pointer)&&(ptr[type]==cint))
  303.             dec();
  304.         store(lval);
  305.         return 0;
  306.         }
  307.     else if (match("-"))
  308.         {k=heir10(lval);
  309.         if(k) rvalue(lval);
  310.         neg();
  311.         return 0;
  312.         }
  313. /*
  314.     complement operator added here
  315. */
  316.     else if (match("~")) {
  317.         k=heir10(lval);
  318.         if(k) rvalue(lval);
  319.         com();
  320.         return 0;
  321.          }
  322.     else if(match("*"))
  323.         {k=heir10(lval);
  324.         if(k) rvalue(lval);
  325.         lval[1]=cint;
  326.         if(ptr=lval[0])
  327.             lval[1]=ptr[type];
  328.         lval[0]=0;
  329.         return 1;
  330.         }
  331.     else if(match("&"))
  332.         {k=heir10(lval);
  333.         if(k==0)
  334.             {error("illegal address");
  335.             return 0;
  336.             }
  337.         else if(lval[1])return 0;
  338.         else
  339.             {immed();
  340.             outstr(ptr=lval[0]);
  341.             nl();
  342.             lval[1]=ptr[type];
  343.             return 0;
  344.             }
  345.         }
  346.     else
  347.         {k=heir11(lval);
  348.         if(match("++"))
  349.             {if(k==0)
  350.                 {needlval();
  351.                 return 0;
  352.                 }
  353.             if(lval[1])push();
  354.             rvalue(lval);
  355.             inc();
  356.             ptr=lval[0];
  357.             if((ptr[ident]==pointer)&&(ptr[type]==cint))
  358.                 inc();
  359.             store(lval);
  360.             dec();
  361.             if((ptr[ident]==pointer)&&(ptr[type]==cint))
  362.                 dec();
  363.             return 0;
  364.             }
  365.         else if(match("--"))
  366.             {if(k==0)
  367.                 {needlval();
  368.                 return 0;
  369.                 }
  370.             if(lval[1])push();
  371.             rvalue(lval);
  372.             dec();
  373.             ptr=lval[0];
  374.             if((ptr[ident]==pointer)&&(ptr[type]==cint))
  375.                 dec();
  376.             store(lval);
  377.             inc();
  378.             if((ptr[ident]==pointer)&&(ptr[type]==cint))
  379.                 inc();
  380.             return 0;
  381.             }
  382.         else return k;
  383.         }
  384. }
  385. /* >>>>>> start of cc7 <<<<<<< */
  386. heir11(lval)
  387.     int *lval;
  388. {
  389.     int k;
  390.     char *ptr;
  391.     k=primary(lval);
  392.     ptr=lval[0];
  393.     blanks();
  394.     if((ch()=='[')||(ch()=='('))
  395.     while(1)
  396.         {if(match("["))
  397.             {if(ptr==0)
  398.                 {error("can't subscript");
  399.                 junk();
  400.                 needbrack("]");
  401.                 return 0;
  402.                 }
  403.             else if(ptr[ident]==pointer) rvalue(lval);
  404.             else if(ptr[ident]!=array)
  405.                 {error("can't subscript");
  406.                 k=0;
  407.                 }
  408.             push();
  409.             expression();
  410.             needbrack("]");
  411.             if(ptr[type]==cint)doublereg();
  412.             addstk();
  413.             lval[0]=0;
  414.             lval[1]=ptr[type];
  415.             k=1;
  416.             }
  417.         else if(match("("))
  418.             {if(ptr==0)
  419.                 {callfunction(0);
  420.                 }
  421.             else if(ptr[ident]!=function)
  422.                 {rvalue(lval);
  423.                 callfunction(0);
  424.                 }
  425.             else callfunction(ptr);
  426.             k=lval[0]=0;
  427.             }
  428.         else return k;
  429.         }
  430.     if(ptr==0)return k;
  431.     if(ptr[ident]==function)
  432.         {immed();
  433.         outstr(ptr);
  434.         nl();
  435.         return 0;
  436.         }
  437.     return k;
  438.     }
  439. primary(lval)
  440.     int *lval;
  441. {
  442.     char *ptr,sname[namesize];
  443.     int num[1],k;
  444.     if(match("("))
  445.         {k=heir1(lval);
  446.         needbrack(")");
  447.         return k;
  448.         }
  449.     if(symname(sname))
  450.         {if(ptr=findloc(sname))
  451.             {getloc(ptr);
  452.             lval[0]=ptr;
  453.             lval[1]=ptr[type];
  454.             if(ptr[ident]==pointer)
  455.                 lval[1]=cint;
  456.             if(ptr[ident]==array) return 0;
  457.             else return 1;
  458.             }
  459.         if(ptr=findglb(sname))
  460.             if(ptr[ident]!=function)
  461.                 {lval[0]=ptr;
  462.                 lval[1]=0;
  463.                 if(ptr[ident]!=array) return 1;
  464.                 immed();
  465.                 outstr(ptr);
  466.                 nl();
  467.                 lval[1]=ptr[type];
  468.                 return 0;
  469.                 }
  470.             ptr=addglb(sname,function,cint,0);
  471.             lval[0]=ptr;
  472.             lval[1]=0;
  473.             return 0;
  474.             }
  475.         if(constant(num))
  476.             return(lval[0]=lval[1]=0);
  477.         else
  478.             {error("invalid expression");
  479.             immed();
  480.             outdec(0);
  481.             nl();
  482.             junk();
  483.             return 0;
  484.             }
  485.         }
  486. store(lval)
  487.     int *lval;
  488. {
  489.     if(lval[1]==0)putmem(lval[0]);
  490.     else putstk(lval[1]);
  491. }
  492. rvalue(lval)
  493.     int *lval;
  494. {
  495.     if((lval[0] !=0) && (lval[1] == 0))
  496.         getmem(lval[0]);
  497.     else indirect(lval[1]);
  498. }
  499. test(label)
  500.     int label;
  501. {
  502.     needbrack("(");
  503.     expression();
  504.     needbrack(")");
  505.     testjump(label);
  506. }
  507. constant(val)
  508.     int val[];
  509. {
  510.     if(number(val))
  511.         immed();
  512.     else if(pstr(val))
  513.         immed();
  514.     else if(qstr(val))
  515.         {immed();
  516.         printlabel(litlab);
  517.         outbyte('+');
  518.         }
  519.     else return 0;
  520.     outdec(val[0]);
  521.     nl();
  522.     return 1;
  523. }
  524. number(val)
  525.     int val[];
  526. {
  527.     int k,minus;
  528.     char c;
  529.     k=minus=1;
  530.     while(k)
  531.         {k=0;
  532.         if (match("+"))
  533.             k=1;
  534.         if(match("-")){
  535.             minus=(-minus);
  536.             k=1;}
  537.         }
  538.     if(numeric(ch())==0)return 0;
  539.     while(numeric(ch()))
  540.         {c=inbyte();
  541.         k=k*10+(c-'0');
  542.         }
  543.     if(minus<0) k=-k;
  544.     val[0]=k;
  545.     return 1;
  546. }
  547. pstr(val)
  548.     int val[];
  549. {
  550.     int k;
  551.     char c;
  552.     k=0;
  553.     if(match("'")==0) return 0;
  554.     while((c=gch())!=39)
  555.         k=(k&255)*256 + (c&127);
  556.     val[0]=k;
  557.     return 1;
  558. }
  559. qstr(val)
  560.     int val[];
  561. {
  562.     char c;
  563.     if(match(quote)==0) return 0;
  564.     val[0]=litptr;
  565.     while (ch()!='"')
  566.         {if(ch()==0) break;
  567.         if(litptr>=litmax)
  568.             {error("string space exhausted");
  569.             while(match(quote)==0)
  570.                 if(gch()==0) break;
  571.             return 1;
  572.             }
  573.         litq[litptr++]=gch();
  574.         }
  575.     gch();
  576.     litq[litptr++]=0;
  577.     return 1;
  578. }
  579.  ë